package com.woniuxy.project.campus.account.redisClint;


import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {
    @Resource
    private   StringRedisTemplate stringRedisTemplate;
    @Resource
    private  RedisTemplate<String, Object> redisTemplate;

    /**
     * 通过键获取字符串值。
     *
     * @param key 要读取的键
     * @return 返回键对应的字符串值，如果不存在则返回 null
     */
    public  String getString(final String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 写入字符串数据到 Redis。
     *
     * @param key   要写入的键
     * @param value 保存的字符串值
     */
    public  void set(final String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    /**
     * 写入字符串数据并设置有效期。
     *
     * @param key     要写入的键
     * @param value   保存的字符串值
     * @param timeout 超时时间，以秒为单位
     */
    public  void set(final String key, String value, long timeout) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 删除指定键的数据。
     *
     * @param key 要删除的键
     */
    public  void delete(final String key) {
        stringRedisTemplate.delete(key);
    }

    /**
     * 检查指定的键是否存在于 Redis 数据库中。
     *
     * @param key 要检查的键
     * @return 如果键存在，则返回 true；否则返回 false
     */
    public  boolean hasKey(final String key) {
        return stringRedisTemplate.hasKey(key);
    }

    /**
     * 获取键的剩余有效时间。
     *
     * @param key 要检查的键
     * @return 剩余的过期时间，以秒为单位
     */
    public  Long ttl(final String key) {
        return stringRedisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 自增键对应的整数值。
     *
     * @param key 要自增的键
     * @return
     */
    public Long increment(final String key) {
        return  stringRedisTemplate.opsForValue().increment(key);
    }

    /**
     * 存储一个字符串集合为 Redis Set。
     *
     * @param key 要存储的键
     * @param set 字符串集合
     */
    public  void sadd(final String key, Set<String> set) {
        String[] str = new String[set.size()];
        stringRedisTemplate.opsForSet().add(key, set.toArray(str));
    }

    /**
     * 获取 Redis Set 中的所有成员。
     *
     * @param key Set 的键
     * @return Set 中的成员集合
     */
    public  Set<String> smembers(final String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }

    /**
     * 从 Redis Set 中删除一个值。
     *
     * @param key   Set 的键
     * @param value 要删除的值
     */
    public  void srem(final String key, String value) {
        stringRedisTemplate.opsForSet().remove(key, value);
    }

    /**
     * 获取有序集合中指定成员的分数。
     *
     * @param key   有序集合的键
     * @param value 成员的值
     * @return 该成员的分数
     */
    public  Double score(final String key, String value) {
        return stringRedisTemplate.opsForZSet().score(key, value);
    }

    /**
     * 将一个值及其分数添加到有序集合中。
     *
     * @param key   有序集合的键
     * @param value 要添加的值
     * @param score 分数
     */
    public  void zadd(final String key, String value, long score) {
        stringRedisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * 增加有序集合中成员的分数。
     *
     * @param key   有序集合的键
     * @param value 成员的值
     * @param score 增加的分数
     */
    public  void zincrby(final String key, String value, long score) {
        stringRedisTemplate.opsForZSet().incrementScore(key, value, score);
    }

    /**
     * 按分数从高到低获取有序集合中成员的值。
     *
     * @param key   有序集合的键
     * @param start 开始索引
     * @param end   结束索引
     * @return 成员的集合
     */
    public  Set<String> zrevrange(final String key, Integer start, Integer end) {
        return stringRedisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 获取有序集合中元素的数量。
     *
     * @param key 有序集合的键
     * @return 集合中的元素数量
     */
    public  Long zcard(final String key) {
        return stringRedisTemplate.opsForZSet().size(key);
    }

    /**
     * 从有序集合中删除一个元素。
     *
     * @param key    有序集合的键
     * @param values 要删除的成员
     */
    public  void zrem(final String key, String values) {
        stringRedisTemplate.opsForZSet().remove(key, values);
    }

    /**
     * 获取有序集合中所有成员。
     *
     * @param key 有序集合的键
     * @return 成员的集合
     */
    public  Set<String> getZSetMembers(String key) {
        return stringRedisTemplate.opsForZSet().range(key, 0, -1);
    }

    /**
     * 存储对象到 Redis，不设置过期时间。
     *
     * @param key   要存储的键
     * @param value 对象值
     * @throws Exception 存储过程中可能的异常
     */
    public  void setObject(String key, Object value) throws Exception {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 存储对象到 Redis，并设置过期时间。
     *
     * @param key     要存储的键
     * @param value   对象值
     * @param timeout 超时时间，以秒为单位
     * @throws Exception 存储过程中可能的异常
     */
    public void setObject(String key, Object value, long timeout) throws Exception {
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 从 Redis 中获取对象。
     *
     * @param key 要获取的键
     * @return 返回对象值
     * @throws Exception 获取过程中可能的异常
     */
    public Object getObject(String key) throws Exception {
        return redisTemplate.opsForValue().get(key);
    }



    /**
     * 存储一个 HashMap 到 Redis。
     *
     * @param key 要存储的键
     * @param map 哈希图
     * @throws Exception 存储过程中可能的异常
     */
    public void setHashMap(String key, HashMap<String, String> map) throws Exception {
        stringRedisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 对哈希表中的某个值自增。
     *
     * @param key     哈希表的键
     * @param hashKey 哈希表中的字段
     * @param number  要增加的数值
     * @throws Exception 自增过程中可能的异常
     */
    public void hashIncrement(String key, String hashKey, long number) throws Exception {
        stringRedisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 获取哈希表中指定字段的值。
     *
     * @param key     哈希表的键
     * @param hashKey 字段的键
     * @return 字段的值
     * @throws Exception 获取过程中可能的异常
     */
    public String getHashMap(String key, String hashKey) throws Exception {
        return (String) stringRedisTemplate.opsForHash().get(key, hashKey);
    }
    /**
     * 获取哈希表中的所有字段和值。
     *
     * @param key 哈希表的键
     * @return 哈希表中的所有字段和值
     * @throws Exception 获取过程中可能的异常
     */
    public HashMap<Object, Object> getHashMapAll(String key) throws Exception {
        return (HashMap<Object, Object>) stringRedisTemplate.opsForHash().entries(key);
    }
    /**
     * 删除hash
     *
     */
    public void deleteHashMap(String key) throws Exception {
        stringRedisTemplate.opsForHash().delete(key);
    }

    public void deleteHash(String key) throws Exception {
        stringRedisTemplate.delete(key);
    }
    /**
     * 保存一个hash
     *
     */
    public void saveHashMap(String key, Map<Object, Object> map) throws Exception {
        stringRedisTemplate.opsForHash().putAll(key, map);
    }
    /**
     * 获取一个值，并自增
     *用来返回 看订单是否重发5次
     */
    public Long incrementCdoe( String key) {
        Long increment = stringRedisTemplate.opsForValue().increment(key);
        return increment;
    }
    /**
     * 对一个键设置过期时间
     */

    public void setExpire(String key, long timeout) {
        stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    }

}